home *** CD-ROM | disk | FTP | other *** search
/ X User Tools / X User Tools (O'Reilly and Associates)(1994).ISO / sources / xman / scllbylc < prev    next >
Text File  |  1994-09-27  |  33KB  |  1,229 lines
  1. /*
  2.  * xman - X window system manual page display program.
  3.  *
  4.  * $XConsortium: ScrollByL.c,v 1.27 91/07/26 18:30:47 dave Exp $
  5.  * $Header: ScrollByL.c,v 1.27 91/07/26 18:30:47 dave Exp $
  6.  *
  7.  * Copyright 1987, 1988 Massachusetts Institute of Technology
  8.  *
  9.  * Permission to use, copy, modify, and distribute this software and its
  10.  * documentation for any purpose and without fee is hereby granted, provided
  11.  * that the above copyright notice appear in all copies and that both that
  12.  * copyright notice and this permission notice appear in supporting
  13.  * documentation, and that the name of M.I.T. not be used in advertising or
  14.  * publicity pertaining to distribution of the software without specific,
  15.  * written prior permission.  M.I.T. makes no representations about the
  16.  * suitability of this software for any purpose.  It is provided "as is"
  17.  * without express or implied warranty.
  18.  *
  19.  * Author:    Chris D. Peterson, MIT Project Athena
  20.  * Created:   December 5, 1987
  21.  */
  22.  
  23. #if ( !defined(lint) && !defined(SABER))
  24.   static char rcs_version[] = "$Athena: ScrollByL.c,v 4.5 88/12/19 13:46:04 kit Exp $";
  25. #endif
  26.  
  27. #include <stdio.h>
  28. #include <ctype.h>
  29.  
  30. #include <X11/IntrinsicP.h>
  31. #include <sys/stat.h>        /* depends on IntrinsicP.h */
  32. #include <X11/StringDefs.h>
  33.  
  34. #include <X11/Xaw/Scrollbar.h>
  35. #include <X11/Xmu/Misc.h>
  36.  
  37. #include "ScrollByLP.h"
  38.  
  39. /* Default Translation Table */
  40.  
  41. static char defaultTranslations[] = 
  42.   "<Key>f:      Page(Forward) \n\
  43.    <Key>b:      Page(Back) \n\
  44.    <Key>1:      Page(Line, 1) \n\
  45.    <Key>2:      Page(Line, 2) \n\
  46.    <Key>3:      Page(Line, 3) \n\
  47.    <Key>4:      Page(Line, 4) \n\
  48.    <Key>\\ :    Page(Forward)";
  49.  
  50.       
  51. /****************************************************************
  52.  *
  53.  * ScrollByLine Resources
  54.  *
  55.  ****************************************************************/
  56.  
  57. #define Offset(field) XtOffset(ScrollByLineWidget, scroll.field)
  58. #define CoreOffset(field) XtOffset(ScrollByLineWidget, core.field)
  59.  
  60. static XtResource resources[] = {
  61.     {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
  62.        CoreOffset(width), XtRImmediate, (caddr_t) 500},
  63.     {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
  64.        CoreOffset(height), XtRImmediate, (caddr_t) 700},
  65.  
  66.     {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  67.        Offset(foreground), XtRString, "XtDefaultForeground"},
  68.     {XtNforceVert, XtCBoolean, XtRBoolean, sizeof(Boolean),
  69.        Offset(force_vert), XtRImmediate, (caddr_t) FALSE},
  70.     {XtNindent, XtCIndent, XtRDimension, sizeof(Dimension),
  71.        Offset(indent), XtRImmediate, (caddr_t) 15},
  72.     {XtNuseRight, XtCBoolean, XtRBoolean, sizeof(Boolean),
  73.        Offset(use_right), XtRImmediate, (caddr_t) FALSE},
  74.     {XtNmanualFontNormal, XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  75.        Offset(normal_font), XtRString, MANPAGE_NORMAL},
  76.     {XtNmanualFontBold, XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  77.        Offset(bold_font), XtRString, MANPAGE_BOLD},
  78.     {XtNmanualFontItalic, XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  79.        Offset(italic_font), XtRString, MANPAGE_ITALIC},
  80.     {XtNmanualFontSymbol, XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  81.        Offset(symbol_font), XtRString, MANPAGE_SYMBOL},
  82.     {XtNfile, XtCFile, XtRFile, sizeof(FILE *),
  83.        Offset(file), XtRImmediate, (caddr_t) NULL},
  84. };
  85.  
  86. #undef Offset
  87. #undef CoreOffset
  88.  
  89. /****************************************************************
  90.  *
  91.  * Full class record constant
  92.  *
  93.  ****************************************************************/
  94.  
  95. static Boolean ScrollVerticalText();
  96. static void MoveAndClearText(), LoadFile(), PrintText(), VerticalJump();
  97. static void VerticalScroll(), SetThumbHeight(), PaintText(), Layout();
  98.  
  99. /* semi - public functions. */
  100.  
  101. static void Realize(), Initialize(), Destroy(), Redisplay(), Page();
  102. static Boolean SetValuesHook();
  103.  
  104. static XtActionsRec actions[] = {
  105.   { "Page",   Page},
  106. };
  107.  
  108. #define superclass        (&simpleClassRec)
  109.  
  110. ScrollByLineClassRec scrollByLineClassRec = {
  111.   {
  112. /* core_class fields      */
  113.     /* superclass         */    (WidgetClass) superclass,
  114.     /* class_name         */    "ScrollByLine",
  115.     /* widget_size        */    sizeof(ScrollByLineRec),
  116.     /* class_initialize   */    NULL,
  117.     /* class_part_init    */    NULL,
  118.     /* class_inited       */    FALSE,
  119.     /* initialize         */    Initialize,
  120.     /* initialize_hook    */    NULL,
  121.     /* realize            */    Realize,
  122.     /* actions            */    actions,
  123.     /* num_actions      */    XtNumber(actions),
  124.     /* resources          */    resources,
  125.     /* num_resources      */    XtNumber(resources),
  126.     /* xrm_class          */    NULLQUARK,
  127.     /* compress_motion      */    TRUE,
  128.     /* compress_exposure  */    FALSE,
  129.     /* compress_enterleave*/    TRUE,
  130.     /* visible_interest   */    FALSE,
  131.     /* destroy            */    Destroy,
  132.     /* resize             */    Layout,
  133.     /* expose             */    Redisplay,
  134.     /* set_values         */    NULL,
  135.     /* set_values_hook    */    SetValuesHook,
  136.     /* set_values_almost  */    XtInheritSetValuesAlmost,
  137.     /* get_values_hook    */    NULL,
  138.     /* accept_focus       */    NULL,
  139.     /* version            */    XtVersion,
  140.     /* callback_private   */    NULL,
  141.     /* tm_table           */    defaultTranslations,
  142.     /* query_geometry      */    XtInheritQueryGeometry,
  143.     /* display_accelerator*/    XtInheritDisplayAccelerator,
  144.     /* extension      */    NULL,
  145.   },
  146.   { /* simple fields */
  147.     /* change_sensitive        */    XtInheritChangeSensitive
  148.   }
  149. };
  150.  
  151. WidgetClass scrollByLineWidgetClass = 
  152.             (WidgetClass) &scrollByLineClassRec;
  153.  
  154.  
  155. /****************************************************************
  156.  *
  157.  * Private Routines
  158.  *
  159.  ****************************************************************/
  160.  
  161. /*    Function Name: Layout
  162.  *    Description: This function lays out the scroll widget.
  163.  *    Arguments: w - the scroll widget.
  164.  *                 key - a boolean: if true then resize the widget to the child
  165.  *                                  if false the resize children to fit widget.
  166.  *    Returns: TRUE if successful.
  167.  */
  168.  
  169. static void
  170. Layout(w)
  171. Widget w;
  172. {    
  173.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  174.   Dimension width, height;
  175.   Widget bar;
  176.   Position bar_bw;
  177.  
  178. /* 
  179.  * For now always show the bar.
  180.  */
  181.  
  182.   bar = sblw->scroll.bar;
  183.   height = sblw->core.height;
  184.   width = sblw->core.width;
  185.   bar_bw = bar->core.border_width;
  186.  
  187.   /* Move child and v_bar to correct location. */
  188.  
  189.   if (sblw->scroll.use_right) {
  190.     XtMoveWidget(bar, width - (bar->core.width + bar_bw), - bar_bw);
  191.     sblw->scroll.offset = 0;
  192.   }
  193.   else {
  194.     XtMoveWidget(bar, - bar_bw, - bar_bw);
  195.     sblw->scroll.offset = bar->core.width + bar_bw;
  196.   }
  197.  
  198.   /* resize the scrollbar to be the correct height or width. */
  199.  
  200.   XtResizeWidget(bar, bar->core.width, height, bar->core.border_width);
  201.  
  202.   SetThumbHeight(w);
  203. }
  204.  
  205. /* ARGSUSED */
  206. static void 
  207. GExpose(w,junk,event,cont)
  208. Widget w;
  209. XtPointer junk;
  210. XEvent *event;
  211. Boolean *cont;
  212. {
  213.  
  214. /*
  215.  * Graphics exposure events are not currently sent to exposure proc.
  216.  */
  217.  
  218.   if (event->type == GraphicsExpose)
  219.     Redisplay(w, event, NULL);
  220.  
  221. } /* ChildExpose */
  222.  
  223. /*
  224.  * Repaint the widget's child Window Widget.
  225.  */
  226.  
  227. /* ARGSUSED */
  228. static void Redisplay(w, event, region)
  229. Widget w;
  230. XEvent *event;
  231. Region region;
  232. {
  233.   int top, height;        /* the locations of the top and height
  234.                    of the region that needs to be repainted. */
  235.   
  236. /*
  237.  * This routine tells the client which sections of the window to 
  238.  * repaint in his callback function which does the actual repainting.
  239.  */
  240.  
  241.   if (event->type == Expose) {
  242.     top = event->xexpose.y;
  243.     height = event->xexpose.height;
  244.   }
  245.   else {
  246.     top = event->xgraphicsexpose.y;
  247.     height  = event->xgraphicsexpose.height;
  248.   }
  249.   
  250.   PaintText(w, top, height);
  251. } /* redisplay (expose) */
  252.  
  253. /*    Function Name: PaintText
  254.  *    Description: paints the text at the give location for a given height.
  255.  *    Arguments: w - the sbl widget.
  256.  *                 y_loc, height - location and size of area to paint.
  257.  *    Returns: none
  258.  */
  259.  
  260. static void
  261. PaintText(w, y_loc, height)
  262. Widget w;
  263. int y_loc, height;
  264. {
  265.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  266.   int start_line, num_lines, location;
  267.  
  268.   start_line = y_loc / sblw->scroll.font_height + sblw->scroll.line_pointer;
  269.  
  270.   if (start_line >= sblw->scroll.lines)
  271.     return;
  272.   
  273.   num_lines = height / sblw->scroll.font_height + 1;
  274.  
  275. /*
  276.  * Only integer arithmetic makes this possible. 
  277.  */
  278.  
  279.   location =  y_loc / sblw->scroll.font_height * sblw->scroll.font_height;
  280.  
  281.   PrintText(w, start_line, num_lines, location);
  282. } 
  283.  
  284. /*    Function Name: Page
  285.  *    Description: This function pages the widget, by the amount it recieves
  286.  *                   from the translation Manager.
  287.  *    Arguments: w - the ScrollByLineWidget.
  288.  *                 event - the event that caused this return.
  289.  *                 params - the parameters passed to it.
  290.  *                 num_params - the number of parameters.
  291.  *    Returns: none.
  292.  */
  293.  
  294. /* ARGSUSED */
  295. static void 
  296. Page(w, event, params, num_params)
  297. Widget w;
  298. XEvent * event;
  299. String * params;
  300. Cardinal *num_params;
  301. {
  302.    ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  303.    Widget bar = sblw->scroll.bar;
  304.  
  305.    if (*num_params < 1)
  306.      return;
  307. /*
  308.  * If no scroll bar is visible then do not page, as the entire window is shown,
  309.  * of scrolling has been turned off. 
  310.  */
  311.  
  312.    if (bar == (Widget) NULL)
  313.      return;
  314.  
  315.    switch ( params[0][0] ) {
  316.    case 'f':
  317.    case 'F':
  318.      /* move one page forward */
  319.      VerticalScroll(bar, NULL, (int) bar->core.height);
  320.      break;
  321.    case 'b':
  322.    case 'B':
  323.      /* move one page backward */
  324.      VerticalScroll(bar, NULL,  - (int) bar->core.height);
  325.      break;
  326.    case 'L':
  327.    case 'l':
  328.      /* move one line forward */
  329.      VerticalScroll(bar, NULL, 
  330.             (int) atoi(params[1]) * sblw->scroll.font_height);
  331.      break;
  332.    default:
  333.      return;
  334.    }
  335. }
  336.  
  337. /*    Function Name: CreateScrollbar
  338.  *    Description: createst the scrollbar for us.
  339.  *    Arguments: w - sblw widget.
  340.  *    Returns: none.
  341.  */
  342.  
  343. static void
  344. CreateScrollbar(w)
  345. Widget w;
  346. {
  347.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  348.   Arg args[5];
  349.   Cardinal num_args = 0;
  350.  
  351.   if (sblw->scroll.bar != NULL) 
  352.     return;
  353.  
  354.   XtSetArg(args[num_args], XtNorientation, XtorientVertical); num_args++;
  355.   
  356.   sblw->scroll.bar = XtCreateWidget("scrollbar", scrollbarWidgetClass, w, 
  357.                     args, num_args);
  358.   XtAddCallback(sblw->scroll.bar, XtNscrollProc, VerticalScroll, NULL);
  359.   XtAddCallback(sblw->scroll.bar, XtNjumpProc, VerticalJump, NULL); 
  360. }
  361.  
  362. /*    Function Name: ScrollVerticalText
  363.  *    Description: This accomplished the actual movement of the text.
  364.  *    Arguments: w - the ScrollByLine Widget.
  365.  *                 new_line - the new location for the line pointer
  366.  *                 force_redisplay - should we force this window to get 
  367.  *                                   redisplayed?
  368.  *    Returns: True if the thumb needs to be moved.
  369.  */
  370.  
  371. static Boolean
  372. ScrollVerticalText(w, new_line, force_redisp)
  373. Widget w;
  374. int new_line;
  375. Boolean force_redisp;
  376. {
  377.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  378.   int num_lines = (int)w->core.height / sblw->scroll.font_height + 1;
  379.   int max_lines, old_line;
  380.   Boolean move_thumb = FALSE;
  381.  
  382. /*
  383.  * Do not let the window extend out of bounds.
  384.  */
  385.  
  386.   if ( new_line < 0) {
  387.     new_line = 0;
  388.     move_thumb = TRUE;
  389.   }
  390.   else {
  391.     max_lines = sblw->scroll.lines - (int)w->core.height / sblw->scroll.font_height;
  392.     AssignMax(max_lines, 0);
  393.  
  394.     if ( new_line > max_lines ) {
  395.       new_line = max_lines;
  396.       move_thumb = TRUE;
  397.     }
  398.   }
  399.  
  400. /* 
  401.  * If forced to redisplay then do a full redisplay and return.
  402.  */
  403.  
  404.   old_line = sblw->scroll.line_pointer;    
  405.   sblw->scroll.line_pointer = new_line;    /* Set current top of page. */
  406.  
  407.   if (force_redisp) 
  408.     MoveAndClearText(w, 0, /* cause a full redisplay */ 0, 0);
  409.  
  410.   if (new_line == old_line)
  411.     return(move_thumb);
  412.  
  413. /*
  414.  * Scroll forward.
  415.  */
  416.  
  417.   else if (new_line < old_line) {
  418.     int lines_to_scroll = old_line - new_line;
  419.     MoveAndClearText(w, 0, num_lines - lines_to_scroll, lines_to_scroll);
  420.   }
  421.  
  422. /* 
  423.  * Scroll back.
  424.  */
  425.  
  426.   else {
  427.     int lines_to_scroll = new_line - old_line;
  428.     MoveAndClearText(w, lines_to_scroll, num_lines - lines_to_scroll, 0);
  429.   }
  430.  
  431.   return(move_thumb);
  432. }
  433.  
  434. /*    Function Name: MoveAndClearText
  435.  *    Description: Blits as much text as it can and clear the
  436.  *                   remaining area with generate exposures TRUE.
  437.  *    Arguments: w - the sbl widget.
  438.  *                 old_y - the old y position.
  439.  *                 height - height of area to move.
  440.  *                 new_y - new y position.
  441.  *    Returns: none
  442.  */
  443.        
  444. static void
  445. MoveAndClearText(w, old_y, height, new_y)
  446. Widget w;
  447. int old_y, new_y, height;
  448. {
  449.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  450.   int from_left = sblw->scroll.indent + sblw->scroll.offset;
  451.   int y_clear;
  452.  
  453.   old_y *= sblw->scroll.font_height;
  454.   new_y *= sblw->scroll.font_height;
  455.   height *= sblw->scroll.font_height;
  456.  
  457. /*
  458.  * If we are already at the right location then do nothing.
  459.  * (height == 0).
  460.  *
  461.  * If we have scrolled more than a screen height then just clear
  462.  * the window.
  463.  */
  464.  
  465.   if (height <= sblw->scroll.font_height) { /* avoid rounding errors. */
  466.     XClearArea( XtDisplay(w), XtWindow(w), from_left, 0, 
  467.            (unsigned int) 0, (unsigned int) 0, FALSE);    
  468.     PaintText(w, 0, (int) sblw->core.height);
  469.     return;
  470.   }
  471.  
  472.   if ((int)height + (int)old_y > (int)w->core.height)
  473.     height = w->core.height - old_y;
  474.  
  475.   XCopyArea(XtDisplay(w), XtWindow(w), XtWindow(w), sblw->scroll.move_gc,
  476.         from_left, old_y, 
  477.         (unsigned int) w->core.width - from_left, (unsigned int) height,
  478.         from_left, new_y);
  479.  
  480.   height -= sblw->scroll.font_height/2;    /* clear 1/2 font of extra space,
  481.                        to make sure we don't lose or
  482.                        gain decenders. */
  483.   if (old_y > new_y)
  484.     y_clear = height;
  485.   else
  486.     y_clear = 0;
  487.   
  488. /*
  489.  * We cannot use generate exposures, since that may allow another move and
  490.  * clear before the area get repainted, this would be bad.
  491.  */
  492.  
  493.   XClearArea( XtDisplay(w), XtWindow(w), from_left, y_clear,
  494.          (unsigned int) 0, (unsigned int) (w->core.height - height),
  495.          FALSE);
  496.   PaintText(w, (int) y_clear, (int) (w->core.height - height));
  497. }
  498.  
  499. /*    Function Name: SetThumbHeight
  500.  *    Description: Set the height of the thumb.
  501.  *    Arguments: w - the sblw widget.
  502.  *    Returns: none
  503.  */
  504.  
  505. static void
  506. SetThumbHeight(w)
  507. Widget w;
  508. {
  509.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  510.   float shown;
  511.  
  512.   if (sblw->scroll.bar == NULL)
  513.     return;
  514.  
  515.   if (sblw->scroll.lines == 0) 
  516.     shown = 1.0;
  517.   else
  518.     shown = (float) w->core.height / (float) (sblw->scroll.lines *
  519.                           sblw->scroll.font_height);
  520.   if (shown > 1.0)
  521.     shown = 1.0;
  522.  
  523.   XawScrollbarSetThumb( sblw->scroll.bar, (float) -1, shown );
  524. }
  525.  
  526. /*    Function Name: SetThumb
  527.  *    Description: Set the thumb location.
  528.  *    Arguments: w - the sblw.
  529.  *    Returns: none
  530.  */
  531.  
  532. static void
  533. SetThumb(w) 
  534. Widget w;
  535. {
  536.   float location;
  537.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  538.  
  539.   if ( (sblw->scroll.lines == 0) || (sblw->scroll.bar == NULL) )
  540.     return;
  541.  
  542.   location = (float) sblw->scroll.line_pointer / (float) sblw->scroll.lines; 
  543.   XawScrollbarSetThumb( sblw->scroll.bar, location , (float) -1 );
  544. }
  545.  
  546. /*    Function Name: VerticalJump.
  547.  *    Description: This function moves the test
  548.  *                   as the vertical scroll bar is moved.
  549.  *    Arguments: w - the scrollbar widget.
  550.  *                 junk - not used.
  551.  *                 percent - the position of the scrollbar.
  552.  *    Returns: none.
  553.  */
  554.  
  555. /* ARGSUSED */
  556. static void
  557. VerticalJump(w, junk, percent_ptr)
  558. Widget w;
  559. caddr_t junk;
  560. caddr_t percent_ptr;
  561. {
  562.   float percent = *((float *) percent_ptr);
  563.   int new_line;            /* The new location for the line pointer. */
  564.   ScrollByLineWidget sblw = (ScrollByLineWidget) XtParent(w);
  565.  
  566.   new_line = (int) ((float) sblw->scroll.lines * percent);
  567.   if (ScrollVerticalText( (Widget) sblw, new_line, FALSE))
  568.     SetThumb((Widget) sblw);
  569. }
  570.  
  571. /*    Function Name: VerticalScroll
  572.  *    Description: This function moves the postition of the interior window
  573.  *                   as the vertical scroll bar is moved.
  574.  *    Arguments: w - the scrollbar widget.
  575.  *                 junk - not used.
  576.  *                 pos - the position of the cursor.
  577.  *    Returns: none.
  578.  */
  579.  
  580. /* ARGSUSED */
  581. static void
  582. VerticalScroll(w,junk,pos)
  583. Widget w;
  584. caddr_t junk;
  585. int pos;
  586. {
  587.   int new_line;            /* The new location for the line pointer. */
  588.   ScrollByLineWidget sblw = (ScrollByLineWidget) XtParent(w);
  589.  
  590.   new_line = sblw->scroll.line_pointer + (pos / sblw->scroll.font_height);
  591.   (void) ScrollVerticalText( (Widget) sblw, new_line, FALSE);
  592.   SetThumb( (Widget) sblw);
  593. }
  594.  
  595. int h_width;            /* main font width */
  596.  
  597. /* ARGSUSED */
  598. static void 
  599. Initialize(req, new)
  600. Widget req, new;
  601. {
  602.   ScrollByLineWidget sblw = (ScrollByLineWidget) new;
  603.   unsigned long figWidth;
  604.   Atom atomNum;
  605.  
  606.   sblw->scroll.top_line = NULL;
  607.   sblw->scroll.line_pointer = 0;
  608.   LoadFile(new);
  609.   sblw->scroll.bar = (Widget) NULL;
  610.  
  611.   sblw->scroll.font_height = (sblw->scroll.normal_font->max_bounds.ascent + 
  612.                   sblw->scroll.normal_font->max_bounds.descent); 
  613.  
  614.   atomNum = XInternAtom(XtDisplay(req), "FIGURE_WIDTH", False);
  615.  
  616.   if (XGetFontProperty(sblw->scroll.normal_font, atomNum, &figWidth))
  617.       h_width = figWidth;
  618.   else
  619.     h_width = XTextWidth(sblw->scroll.normal_font, "$", 1);
  620.  
  621.  
  622.  
  623. } /* Initialize. */
  624.  
  625. /*    Function Name: CreateGCs
  626.  *    Description: Creates the graphics contexts that we need. 
  627.  *    Arguments: w - the sblw.
  628.  *    Returns: none
  629.  */
  630.  
  631. static void
  632. CreateGCs(w) 
  633. Widget w;
  634. {
  635.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  636.  
  637.   XtGCMask mask;
  638.   XGCValues values;
  639.  
  640.   values.graphics_exposures = TRUE;
  641.   sblw->scroll.move_gc = XtGetGC(w, GCGraphicsExposures, &values);
  642.  
  643.   mask = GCForeground | GCFont;
  644.   values.foreground = sblw->scroll.foreground;
  645.   
  646.   values.font = sblw->scroll.normal_font->fid;
  647.   sblw->scroll.normal_gc = XtGetGC(w, mask, &values);
  648.  
  649.   values.font = sblw->scroll.italic_font->fid;
  650.   sblw->scroll.italic_gc = XtGetGC(w, mask, &values);
  651.  
  652.   values.font = sblw->scroll.bold_font->fid;
  653.   sblw->scroll.bold_gc = XtGetGC(w, mask, &values);
  654.  
  655.   values.font = sblw->scroll.symbol_font->fid;
  656.   sblw->scroll.symbol_gc = XtGetGC(w, mask, &values);
  657. }
  658.  
  659. /*    Function Name: DestroyGCs
  660.  *    Description: removes all gcs for this widget.
  661.  *    Arguments: w - the widget.
  662.  *    Returns: none
  663.  */
  664.  
  665. static void
  666. DestroyGCs(w)
  667. Widget w;
  668. {
  669.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  670.  
  671.   XtReleaseGC(w, sblw->scroll.normal_gc);
  672.   XtReleaseGC(w, sblw->scroll.bold_gc);
  673.   XtReleaseGC(w, sblw->scroll.italic_gc);
  674.   XtReleaseGC(w, sblw->scroll.move_gc);
  675. }
  676.  
  677. static void
  678. Realize(w, valueMask, attributes)
  679. register Widget w;
  680. Mask *valueMask;
  681. XSetWindowAttributes *attributes;
  682. {
  683.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  684.  
  685.   CreateScrollbar(w);
  686.   CreateGCs(w);
  687.   Layout(w);
  688.   (*superclass->core_class.realize) (w, valueMask, attributes);
  689.   XtRealizeWidget(sblw->scroll.bar); /* realize scrollbar. */
  690.   XtMapWidget(sblw->scroll.bar); /* map scrollbar. */
  691.  
  692.   XtAddEventHandler(w, 0, TRUE, GExpose, NULL); /* Get Graphics Exposures */
  693. } /* Realize */
  694.  
  695. /*    Function Name: Destroy
  696.  *    Description: Cleans up when we are killed.
  697.  *    Arguments: w - the widget.
  698.  *    Returns: none
  699.  */
  700.  
  701. static void
  702. Destroy(w)
  703. Widget w;
  704. {
  705.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  706.  
  707.   if (sblw->scroll.bar != NULL)
  708.     XtDestroyWidget(sblw->scroll.bar); /* Destroy scrollbar. */
  709.   if (sblw->scroll.file != NULL)
  710.     fclose(sblw->scroll.file);
  711.   DestroyGCs(w);
  712. }
  713.  
  714. /*
  715.  *
  716.  * Set Values
  717.  *
  718.  */
  719.  
  720. /* ARGSUSED */
  721. static Boolean 
  722. SetValuesHook( w, args, num_args)
  723. Widget w;
  724. ArgList args;
  725. Cardinal *num_args;
  726. {
  727.   Boolean ret = TRUE;
  728.   int i;
  729.  
  730.   for (i = 0; i < *num_args; i++) {
  731.     if (strcmp(XtNfile, args[i].name) == 0) {
  732.       LoadFile(w);
  733.       ret = TRUE;
  734.     }
  735.   }
  736.  
  737. /*
  738.  * Changing anthing else will have strange effects, I don't need it so
  739.  * I didn't code it.
  740.  */
  741.  
  742.   return(ret);
  743.  
  744. } /* Set Values */
  745.  
  746. /* 
  747.  * A little design philosophy is probabally wise to include at this point.
  748.  *
  749.  * One of the things that I has hoped to achieve with xman is to make the
  750.  * viewing of manpage not only easy for the nieve user, but also fast for
  751.  * the experienced user, I wanted to be able to use it too.  To achieve this
  752.  * I end up sacrificing a bit of start up time for the manual data structure.
  753.  * As well as, the overhead of reading the entire file before putting it up 
  754.  * on the display.  This is actually hardly even noticeable since most manual
  755.  * pages are shots, one to two pages - the notable exception is of course csh,
  756.  * but then that should be broken up anyway. 
  757.  *
  758.  * METHOD:
  759.  *
  760.  * I allocate a chunk of space that is the size of the file, plus a null for
  761.  * debugging.  Then copiesthe file into this chunk of memory.  I then allocate
  762.  * an array of char*'s that are assigned to the beginning of each line.  Yes,
  763.  * this means that I have to read the file twice, and could probabally be more
  764.  * clever about it, but once it is in memory the second read is damn fast.
  765.  * There are a few obsucrities here about guessing the number of lines and
  766.  * reallocing if I guess wrong, but other than that it is pretty straight 
  767.  * forward.
  768.  *
  769.  *                                         Chris Peterson
  770.  *                                         1/27/88
  771.  */
  772.  
  773. #define ADD_MORE_MEM 100    /* first guesses for allocations. */
  774. #define CHAR_PER_LINE 40
  775.  
  776. /*    Function Name: LoadFile
  777.  *    Description: Loads the current file into the internal memory.
  778.  *    Arguments: w - the sblw.
  779.  *    Returns: none
  780.  */
  781.  
  782. static void
  783. LoadFile(w)
  784. Widget w;
  785. {
  786.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  787.   FILE * file = sblw->scroll.file;
  788.  
  789.   char *page;
  790.   char **line_pointer,**top_line; /* pointers to beginnings of the 
  791.                      lines of the file. */
  792.   int nlines;            /* the current number of allocated lines. */
  793.   struct stat fileinfo;        /* file information from fstat. */
  794.  
  795.   if ( sblw->scroll.top_line != NULL) {
  796.     XtFree(*(sblw->scroll.top_line)); /* free characters. */
  797.     XtFree((char *)(sblw->scroll.top_line)); /* free lines. */
  798.   }
  799.   sblw->scroll.top_line = NULL;
  800.  
  801.   if (file == NULL)
  802.     return;
  803.  
  804. /*
  805.  * Get file size and allocate a chunk of memory for the file to be 
  806.  * copied into.
  807.  */
  808.  
  809.   if (fstat(fileno(file), &fileinfo))
  810.     XtAppError(XtWidgetToApplicationContext(w), 
  811.            "SBLW LoadFile: Failure in fstat.");
  812.  
  813. /* 
  814.  * Allocate a space for a list of pointer to the beginning of each line.
  815.  */
  816.  
  817.   if ( (nlines = fileinfo.st_size/CHAR_PER_LINE) == 0)
  818.     return;
  819.  
  820.   page = XtMalloc(fileinfo.st_size + 1); /* leave space for the NULL */
  821.   top_line = line_pointer = (char**) XtMalloc( nlines * sizeof(char *) );
  822.  
  823. /*
  824.  * Copy the file into memory. 
  825.  */
  826.  
  827.   if (fread(page, sizeof(char), fileinfo.st_size, file) == 0)
  828.     XtAppError(XtWidgetToApplicationContext(w), 
  829.            "SBLW LoadFile: Failure in fread.");
  830.  
  831.  
  832. /* put NULL at end of buffer. */
  833.  
  834.   *(page + fileinfo.st_size) = '\0';
  835.  
  836. /*
  837.  * Go through the file setting a line pointer to the character after each 
  838.  * new line.  If we run out of line pointer space then realloc that space
  839.  * with space for more lines.
  840.  */
  841.  
  842.   *line_pointer++ = page;    /* first line points to first char in buffer.*/
  843.   while (*page != '\0') {
  844.  
  845.     if ( *page == '\n' ) {
  846.       *line_pointer++ = page + 1;
  847.  
  848.       if (line_pointer >= top_line + nlines) {
  849.     top_line = (char **) XtRealloc( (char *)top_line, (nlines +
  850.                       ADD_MORE_MEM) * sizeof(char *) );
  851.     line_pointer = top_line + nlines;
  852.     nlines += ADD_MORE_MEM;
  853.       }
  854.     }
  855.     page++;
  856.   }
  857.    
  858. /*
  859.  *  Realloc the line pointer space to take only the minimum amount of memory
  860.  */
  861.  
  862.   sblw->scroll.lines = nlines = line_pointer - top_line - 1;
  863.   top_line = (char **) XtRealloc((char *)top_line, nlines * sizeof(char *));
  864.  
  865. /*
  866.  * Store the memory pointers
  867.  */
  868.  
  869.   sblw->scroll.top_line = top_line;
  870.   sblw->scroll.line_pointer = 0;
  871.   SetThumbHeight(w);
  872.   SetThumb(w);
  873. }
  874.  
  875. #define NLINES  66        /* This is the number of lines to wait until
  876.                    we boldify the line again, this allows 
  877.                    me to bold the first line of each page.*/
  878. #define BACKSPACE 010        /* I doubt you would want to change this. */
  879.  
  880. #define NORMAL    0
  881. #define BOLD    1
  882. #define ITALIC    2
  883. #define SYMBOL    3
  884. #define WHICH(italic, bold)    ((bold) ? BOLD : ((italic) ? ITALIC : NORMAL))
  885.                 /* Choose BOLD over ITALICS.  If neither */
  886.                 /* is chosen, use NORMAL. */
  887.  
  888. static int DumpText();
  889. static Boolean Boldify();    
  890.  
  891. /*    Function Name: PrintText
  892.  *    Description: This function actually prints the text.
  893.  *    Arguments: w - the ScrollByLine widget.
  894.  *                 start_line - line to start printing,
  895.  *                 num_lines - the number of lines to print.
  896.  *                 location - the location to print the text.
  897.  *    Returns: none.
  898.  */
  899.  
  900. /* ARGSUSED */
  901.  
  902. static void
  903. PrintText(w, start_line, num_lines, location)
  904. Widget w;
  905. int  start_line, num_lines, location;
  906. {
  907.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  908.  
  909.   register char *bufp, *c;    /* Generic char pointers */
  910.   int current_line;        /* the number of the currrent line */
  911.   char buf[BUFSIZ];        /* Misc. characters */
  912.   int width;            /* Width of a tab stop. */
  913.   Boolean italicflag = FALSE;    /* Print text in italics?? */
  914.   Boolean first = TRUE;            /* First line of a manual page??? */
  915.   int x_loc, y_loc;        /* x and y location of text. */
  916.  
  917. /*
  918.  * For table hack
  919.  * To get columns to line up reasonably in most cases, make the
  920.  * assumption that they were lined up using lots of spaces, where
  921.  * lots is greater than two. Use a space width of 70% of the
  922.  * widest character in the font.
  923.  */
  924.   XFontStruct * h_font;
  925.   int h_col, h_fix;
  926.   char * h_c;
  927.  
  928.   h_font = sblw->scroll.normal_font;
  929.  
  930. /*
  931.  * Nothing loaded, take no action.
  932.  */
  933.  
  934.   if (sblw->scroll.top_line == NULL || num_lines == 0)
  935.     return;
  936.  
  937.   current_line = start_line;
  938.  
  939. /* Set the first character to print at the first line. */
  940.  
  941.   c = *(sblw->scroll.top_line + start_line);
  942.  
  943.  /* Width of a tab stop. */
  944.   width = 8 * h_width;
  945.  
  946. /*
  947.  * Because XDrawString uses the bottom of the text as a position
  948.  * reference, add the height from the top of the font to the baseline
  949.  * to the ScollByLine position reference.
  950.  */
  951.  
  952.   y_loc = location + sblw->scroll.normal_font->max_bounds.ascent;
  953.  
  954. /*
  955.  * Ok, here's the more than mildly heuristic man page formatter.
  956.  * We put chars into buf until either a font change or newline
  957.  * occurs (at which time we flush it to the screen.)
  958.  */
  959.  
  960.  
  961.   bufp = buf;
  962.   x_loc = sblw->scroll.offset + sblw->scroll.indent;
  963.   h_col = 0;
  964.   
  965. /*
  966.  * A fix:
  967.  * Assume that we are always starting to print on or before the
  968.  * first line of a page, and then prove it if we aren't.
  969.  */
  970.   for (h_fix = 1; h_fix <= (start_line % NLINES); h_fix++)
  971.     if (**(sblw->scroll.top_line + start_line - h_fix) != '\n')
  972.       {
  973.     first = FALSE;
  974.     break;
  975.       }
  976.  
  977.   while(TRUE) {
  978.     if (current_line % NLINES == 0)
  979.       first = TRUE;
  980.  
  981. /* 
  982.  * Lets make sure that we do not run out of space in our buffer, making full
  983.  * use of it is not critical since no window will be wide enough to display
  984.  * nearly BUFSIZ characters.
  985.  */
  986.  
  987.     if ( (bufp - buf) > (BUFSIZ - 10) )
  988.       /* Toss everything until we find a <CR> or the end of the buffer. */
  989.       while ( (*c != '\n') && (*c != '\0') ) c++;
  990.  
  991.     switch(*c) {
  992.  
  993.     case '\0':              /* If we reach the end of the file then return */
  994.       DumpText(w, x_loc, y_loc, buf, bufp - buf, WHICH(italicflag, first));
  995.       return;
  996.  
  997.     case '\n':
  998.       if (bufp != buf) {
  999.     Boolean bold;
  1000.     *bufp = '\0';        /* for Boldify. */
  1001.     bold = ( (first) || ((x_loc == (sblw->scroll.offset +
  1002.                   sblw->scroll.indent)) && Boldify(buf)) );
  1003.  
  1004.     (void) DumpText(w, x_loc, y_loc, buf, bufp - buf,
  1005.             WHICH(italicflag, bold));
  1006.  
  1007.     if (bold)
  1008.       first = FALSE;
  1009.       }
  1010.  
  1011. /* 
  1012.  * If we have painted the required number of lines then we should now return.
  1013.  */
  1014.       if (++current_line == start_line + num_lines ) 
  1015.     return;
  1016.  
  1017.       bufp = buf;
  1018.       italicflag = FALSE;
  1019.       x_loc = sblw->scroll.offset + sblw->scroll.indent;
  1020.       h_col = 0;
  1021.       y_loc += sblw->scroll.font_height;
  1022.       break;
  1023.  
  1024. /*
  1025.  * This tab handling code is not very clever it moves the cursor over
  1026.  * to the next boundry of eight (8) spaces, as calculated in width just
  1027.  * before the printing loop started.
  1028.  */
  1029.  
  1030.     case '\t':            /* TAB */
  1031.       x_loc = DumpText(w, x_loc, y_loc, buf, bufp - buf,
  1032.                WHICH(italicflag, first));
  1033.       h_col += bufp - buf;
  1034.       bufp = buf; 
  1035.       italicflag = FALSE;
  1036.       x_loc = sblw->scroll.offset + sblw->scroll.indent;
  1037.       h_col = h_col + 8 - (h_col%8);
  1038.       x_loc += h_width * h_col;
  1039.       break;
  1040.  
  1041.     case ' ':
  1042.       h_c = c + 1;
  1043.       while (*h_c == ' ') h_c++;
  1044.  
  1045.       if (h_c - c < 4)
  1046.     {
  1047.       *bufp++ = *c;
  1048.       break;
  1049.     }
  1050.  
  1051.       x_loc = DumpText(w, x_loc, y_loc, buf, bufp - buf,
  1052.                WHICH(italicflag, first));
  1053.       h_col += bufp - buf;
  1054.       bufp = buf; 
  1055.       italicflag = FALSE;
  1056.  
  1057.       x_loc = sblw->scroll.offset + sblw->scroll.indent; 
  1058.       h_col += (h_c - c);
  1059.       x_loc += h_width * h_col; 
  1060.       c = h_c - 1;
  1061.       break;
  1062.  
  1063.     case '\033':        /* ignore esc sequences for now */
  1064.       c++;            /* should always be esc-x */
  1065.       break;
  1066.  
  1067. /* 
  1068.  * Overstrike code supplied by: cs.utexas.edu!ut-emx!clyde@rutgers.edu 
  1069.  * Since my manual pages do not have overstrike I couldn't test this.
  1070.  */
  1071.  
  1072.     case BACKSPACE:        /* Backspacing for nroff bolding */
  1073.       if (c[-1] == c[1] && c[1] != BACKSPACE) {    /* overstriking one char */
  1074.     bufp--;        /* Zap 1st instance of char to bolden */
  1075.     if (bufp > buf) {
  1076.       x_loc = DumpText(w, x_loc, y_loc, buf, bufp - buf,
  1077.                WHICH(italicflag, FALSE));
  1078.       h_col += bufp - buf;
  1079.       bufp = buf;
  1080.     }
  1081.     *bufp++ = c[1];
  1082.     x_loc = DumpText(w, x_loc, y_loc, buf, bufp - buf, BOLD);
  1083.     h_col += bufp - buf;
  1084.     bufp = buf;
  1085.     first = FALSE;
  1086.  
  1087.     /*
  1088.      *     Nroff bolding looks like:
  1089.      *              C\bC\bC\bCN...
  1090.      * c points to ----^      ^
  1091.      * it needs to point to --^
  1092.      */
  1093.     while (*c == BACKSPACE && c[-1] == c[1])
  1094.       c += 2;
  1095.     c--;        /* Back up to previous char */
  1096.       }
  1097.       else {
  1098.     if ((c[-1] == 'o' && c[1] == '+')          /* Nroff bullet */
  1099.         || (c[-1] == '+' && c[1] == 'o')) {       /* Nroff bullet */
  1100.                 /* If we run into a bullet, print out */
  1101.                 /* everything that's accumulated to this */
  1102.                 /* point, then the bullet, then resume. */
  1103.       bufp--;
  1104.       x_loc = DumpText(w, x_loc, y_loc, buf, bufp - buf,
  1105.                WHICH(italicflag, FALSE));
  1106.       h_col += bufp - buf;
  1107.       bufp = buf;
  1108.       *bufp = (char)183;
  1109.       x_loc = DumpText(w, x_loc, y_loc, buf, 1, SYMBOL);
  1110.       h_col++;
  1111.       c++;
  1112.     }
  1113.     else {        /* 'real' backspace - back up output ptr */
  1114.       bufp--;
  1115.     }
  1116.       }
  1117.       break;
  1118.  
  1119. /* End of contributed overstrike code. */
  1120.   
  1121.    case '_':            /* look for underlining [italicize] */
  1122.       if(*(c + 1) == BACKSPACE) {
  1123.     if(!italicflag) {    /* font change? */
  1124.       if (bufp != buf) {
  1125.         x_loc = DumpText(w, x_loc, y_loc, buf, bufp - buf, NORMAL);
  1126.         h_col += bufp - buf;
  1127.         bufp = buf;
  1128.       }
  1129.       italicflag = TRUE;
  1130.     }
  1131.     c += 2;
  1132.     *bufp++ = *c;
  1133.     break;
  1134.       }
  1135.       /* else fall through to default, because this was a real underscore. */
  1136.  
  1137.     default:
  1138.       if(italicflag) {             /* font change? */
  1139.     if (bufp != buf) {
  1140.       x_loc = DumpText(w, x_loc, y_loc, buf, bufp - buf,
  1141.                WHICH(italicflag, FALSE));
  1142.       h_col += bufp - buf;
  1143.       bufp = buf;
  1144.     }
  1145.     italicflag = FALSE;
  1146.       }
  1147.       *bufp++ = *c;
  1148.       break;
  1149.     }
  1150.     c++;
  1151.   }
  1152. }
  1153.  
  1154. /*    Function Name: DumpText
  1155.  *    Description: Dumps text to the screen.
  1156.  *    Arguments: w - the widget.
  1157.  *                 x_loc - to dump text at.
  1158.  *                 y_loc - the y_location to draw_text.
  1159.  *                 buf - buffer to dump.
  1160.  *                 italic, bold, boolean that tells us which gc to use.
  1161.  *    Returns: x_location of the end of the text.
  1162.  */
  1163.  
  1164. static int
  1165. DumpText(w, x_loc, y_loc, buf, len, format)
  1166. Widget w;
  1167. int x_loc, y_loc;
  1168. char * buf;
  1169. int len;
  1170. int format;
  1171. {
  1172.   ScrollByLineWidget sblw = (ScrollByLineWidget) w;
  1173.   GC gc;
  1174.   XFontStruct * font;
  1175.  
  1176.   switch(format) {
  1177.  
  1178.   case ITALIC:
  1179.     gc = sblw->scroll.italic_gc;
  1180.     font = sblw->scroll.italic_font;
  1181.     break;
  1182.  
  1183.   case BOLD:
  1184.       gc = sblw->scroll.bold_gc;
  1185.       font = sblw->scroll.bold_font;
  1186.     break;
  1187.  
  1188.   case SYMBOL:
  1189.     gc = sblw->scroll.symbol_gc;
  1190.     font = sblw->scroll.symbol_font;
  1191.     break;
  1192.  
  1193.   default:
  1194.       gc = sblw->scroll.normal_gc;
  1195.       font = sblw->scroll.normal_font;
  1196.     break;
  1197.     }
  1198.  
  1199.   XDrawString(XtDisplay(w), XtWindow(w), gc, x_loc, y_loc, buf, len);
  1200.   return(x_loc + XTextWidth(font, buf, len));
  1201. }
  1202.  
  1203. /*    Function Name: Boldify
  1204.  *    Description: look for keyword.
  1205.  *    Arguments: sp - string pointer.
  1206.  *    Returns: 1 if keyword else 0.
  1207.  */
  1208.  
  1209. static Boolean
  1210. Boldify(sp)
  1211. register char *sp;
  1212. {
  1213.   register char *sp_pointer;
  1214.   int length,count;
  1215.  
  1216. /* 
  1217.  * If there are not lower case letters in the line the assume it is a
  1218.  * keyword and boldify it in PrintManpage.
  1219.  */
  1220.  
  1221.   length = strlen(sp);
  1222.   for (sp_pointer = sp, count = 0; count < length; sp_pointer++,count++) 
  1223.     if ( !isupper(*sp_pointer) && !isspace(*sp_pointer) )
  1224.       return(0);
  1225.   return(1);
  1226. }
  1227.  
  1228. #undef superclass
  1229.